When programming extensive computer applications with a high complexity as well as a high flexibility there is a wish to factor out common functionality. Functionality is commonly reused on a “cut and paste” basis and it is difficult to interface between the different constituent components because there is no clear encapsulation of functionality and separation of data and methods. This leads to inconsistencies and low quality, because a reused piece of functionality has no intelligence—it does not know where it came from, and does not synchronize automatically with its progenitor. Furthermore, maintenance is laborious, because the same functionality is repeated, maybe with slight variants, in a lot of places. It takes time to identify all places where an update is required, and the process requires manual intervention and is therefore error-prone.
A way to overcome some of these problems is to use Object Oriented programming. In Object Oriented programming:                Reuse is controlled, as common functionality can be factored out into objects with well-defined interfaces.        Interoperability is facilitated, because objects have well-defined and well described interfaces.        Variance can be controlled by use of inheritance. Inheritance makes sure that any change to the progenitor will be applied to its descendants.        The level of abstraction is supposedly heightened, as objects should ideally be rooted in the business problem domain, not in the “computer” domain.Still,        extending a solution can be a bottleneck, because the programmer is responsible for the infrastructure without which there is no application        
A more structured way of using Object Oriented programming can be provided in a framework. An advantage of a “framework” for application development is that the common functionality is provided in the framework, not in libraries or utility classes. The framework, basically, becomes a framework by providing common functionality plus setting the infrastructure of a working program. However also this kind of programming is also based on inheritance and cannot be easily upgraded.
Within the last couple of years several attempts of creating a framework-based programming language that organizes the programming code for the programmer have been suggested. The overall idea by introducing this programming technique is that all Objects are based on predefined pieces of code. Among others are “Subject-Oriented Programming” by IBM and “Aspect-Oriented Programming” by Xerox PARC Software.
Even though this way of programming helps the programmer organize the objects, the programmer is still responsible for describing how these pieces of functionality interact by writing code from scratch, and writing how these pieces of functionality are combined. This process is also known as “weavings”.
It is a disadvantage of these framework-based programming languages that basically all the weaving has to or at least checked every time the pieces of functionality change. This makes upgrading the framework complicated and expensive.
Furthermore, since some functionality of an object will be provided in the weaving code, it is impossible for the framework to guarantee a system-wide quality of the application, because the framework has no way of knowing what the weaving code does.
A task oriented user interface increases ease of use of the system because the user will be guided through the system. The task will all resemble how the user thinks he/she should do the job. This will aid and assist the user in doing his job.
In a webbased environment, pages have to be simple and task based because each piece of information has to be sent to a server. Then the server responds with the next step and so on. Good web design means focusing on a single task per page and providing (explicit i.e. not just the forward and backwards buttons) navigation forward and backward through pages. Similarly, inductive navigation starts with focusing the activity on each page to a single, primary task. The main principles of inductive navigation can be summed up with the following four steps                1. Focus each page on a single task        2. State/name the task        3. Make the page's content suit the task. The task is stated on the page. It should be obvious how to carry out the task with the controls on the page.        4. Offer links to secondary tasks.        
Similarly to the web design the next task is generated and presented to the user. Each task sequence has to be programmed in advance in order to be able to present the right order of tasks for the user. This is done in the component that controls the UI. It is a disadvantage that all possible task sequences have to be programmed.